WEBVTT

00:00:09.784 --> 00:00:11.867
시작하겠습니다!

00:00:13.038 --> 00:00:15.888
CS231n 14강에 오신 것을 환영합니다.

00:00:15.888 --> 00:00:20.884
이번 시간에는 강화학습을 배워보겠습니다.

00:00:20.884 --> 00:00:23.222
우선 공지사항을 전달하겠습니다.

00:00:23.222 --> 00:00:30.346
어제 저녁 중간고사 점수를 공개했습니다.
자세한 정보는 Piazza에서 확인하시기 바랍니다.

00:00:30.346 --> 00:00:35.402
그리고 두 번째 과제 및 마일스톤 점수는
주말 중으로 공개하도록 하겠습니다.

00:00:36.768 --> 00:00:40.682
프로젝트와 관련한 전달사항도 있습니다.
모든 팀은 반드시 프로젝트를 등록하셔야 합니다.

00:00:40.682 --> 00:00:47.580
Piazza에서 양식 확인 후 작성 바라며

00:00:47.580 --> 00:00:53.214
여러분이 작성하신 문서는 최종 학점에 반영되며
포스터 세션에서 활용 할 예정입니다.

00:00:53.214 --> 00:01:01.779
Tiny ImageNet Challenge에 쓰일 서버가 열렸습니다.

00:01:01.779 --> 00:01:06.193
그리고 며칠전 Piazza에 CS231n 수업평가
설문을 게시하였습니다.

00:01:06.193 --> 00:01:13.600
아직 진행하지 않으신 분들께서는 설문을 부탁드리며
CS231n의 성장을 위한 아주 소중한 피드백이 될 것입니다.

00:01:16.589 --> 00:01:19.650
자 오늘의 주제는 강화학습(reinforcement learning) 입니다.

00:01:19.650 --> 00:01:22.544
우리는 지금까지는
supervised learning을 배웠습니다.

00:01:22.544 --> 00:01:30.498
데이터인 x와 레이블인 y가 있었고, x를 y에 매핑하는
함수를 학습하는게 목표였습니다.

00:01:30.498 --> 00:01:35.067
가령 classification 문제가 있었습니다.

00:01:35.067 --> 00:01:37.753
그리고 지난 강의에서는
unsupervised learning을 배웠습니다.

00:01:37.753 --> 00:01:45.362
데이터는 있지만 레이블이 없는 경우였습니다. 데이터에 내재된
숨겨진 구조를 학습하는게 목표였습니다.

00:01:45.362 --> 00:01:50.528
가령 생성모델(generative models)이 있었습니다.

00:01:52.040 --> 00:01:57.370
이번에 배우는 것은 조금 다릅니다.
강화학습이라는 문제입니다.

00:01:57.370 --> 00:02:01.824
여기에는 에이전트(agent)가 있습니다. 환경(environment)
에서 행동(action)을 취하는 주체입니다.

00:02:01.824 --> 00:02:04.352
에이전트는 행동에 따른
적절한 보상(rewards)을 받습니다.

00:02:04.352 --> 00:02:09.959
강화학습은 에이전트의 보상을 최대화할 수 있는
행동이 무엇인지를 학습하는 것입니다.

00:02:09.959 --> 00:02:14.101
오늘은 이에 대해서 자세하게 다뤄볼 것입니다.

00:02:14.101 --> 00:02:18.116
이번 수업의 개요를 말씀드리자면
우선 강화학습이 어떤 문제인지를 다루고

00:02:18.116 --> 00:02:20.927
그리고 Markov Decision Processes(MDP)
에 대해서 다룰 것입니다.

00:02:20.927 --> 00:02:24.747
MDP는 강화학습 문제의 수식체계(formalism) 입니다.

00:02:24.747 --> 00:02:31.095
그리고 대표적인 강화학습 방법인 Q-Learning과
Policy Gradients에 대해서 배워보겠습니다.

00:02:32.876 --> 00:02:38.936
강화학습의 문제에서는 에이전트와 환경이 있습니다.

00:02:38.936 --> 00:02:43.268
환경에서 에이전트에게는 상태가 주어집니다.

00:02:43.268 --> 00:02:46.877
그리고 에이전트는 어떤 행동을 취하게 됩니다.

00:02:46.877 --> 00:02:52.609
그러면 환경은 행동에 따라 에이전트에게
보상을 주고 다음 상태를 부여합니다.

00:02:52.609 --> 00:03:00.918
이 과정은 에이전트가 종료상태(terminal state)가
될 때 까지 반복됩니다. 종료가 되면 한 에피소드가 끝나는 것이죠

00:03:00.918 --> 00:03:03.401
자 그럼 몇 가지 예시를 한번 살펴보겠습니다.

00:03:03.401 --> 00:03:05.536
우선 "cart-pole" 문제입니다.

00:03:05.536 --> 00:03:11.142
"cart-pole"는 아주 고전적인 문제입니다.
이미 CS229에서 접해보신 분들도 계실 것입니다.

00:03:11.142 --> 00:03:16.252
"cart-pole" 문제의 목표는 움직이는 카트(cart)와 카트 위에
매달려있는 막대기(pole)의 균형을 유지하는 것입니다.

00:03:16.252 --> 00:03:20.280
상태(state)에는 현재 시스템이 기술되어있습니다.

00:03:20.280 --> 00:03:28.206
가령, 막대기의 각,막대기의 각속도,
카트의 위치,카트의 수평속도가 있습니다.

00:03:28.206 --> 00:03:33.224
에이전트는 카트를 수평으로 미는 행동을 취할 수 있습니다.
(horizontal forces)

00:03:33.224 --> 00:03:38.387
우리는 카트를 밀면서 동시에
막대기의 균형을 잘 유지해야 합니다.

00:03:38.387 --> 00:03:43.990
환경으로 부터 받을 수 있는 보상은
"막대기가 제대로 서 있으면 1점" 입니다.

00:03:43.990 --> 00:03:48.143
여러분은 막대기를 가능한 똑바로 세워야 합니다.

00:03:49.286 --> 00:03:52.192
고전적인 RL문제에서 다뤘던 다양한 예시들을 살펴보겠습니다.

00:03:52.192 --> 00:03:53.998
"로봇 보행(robot locomotion)"  문제가 있습니다.

00:03:53.998 --> 00:03:59.670
여기 휴머노이드 로봇 모델과
개미 로봇 모델이 있습니다.

00:03:59.670 --> 00:04:03.128
로봇이 앞으로 나아가도록 하는 것이 목표입니다.

00:04:03.128 --> 00:04:10.807
이 문제에서 상태(state)는 로봇의
모든 관절들의 각과 위치입니다.

00:04:10.807 --> 00:04:15.887
에이전트가 취할 수 있는 행동(Action)은
각 관절들에 가해지는 토크(torques) 입니다.

00:04:15.887 --> 00:04:21.228
이 문제에서 하고싶은 것은 로봇이 앞으로 전진하는 것입니다.
앞으로 이동하면 보상을 받고

00:04:21.228 --> 00:04:31.701
휴머노이드 로봇의 경우에는 로봇에 똑바로 서 있는
경우에도 추가적인 보상을 받습니다.

00:04:33.521 --> 00:04:38.384
RL로 게임 문제도 풀 수 있습니다.

00:04:38.384 --> 00:04:40.700
가령 여기 아타리 게임(Atrari games)이 있습니다.

00:04:40.700 --> 00:04:44.280
깊은 강화학습(Deep reinforcement learning)가
아주 큰 성과를 이룬 종목이기도 합니다.

00:04:44.280 --> 00:04:48.574
아타리 게임에서는 가능한 가장 높은 점수로
게임을 끝마치는 것이 목적입니다.

00:04:48.574 --> 00:04:52.753
에이전트가 게임 플레이어가 되어
게임을 진행하게 됩니다.

00:04:52.753 --> 00:04:57.506
현재 게임 진행 화면 그대로
(raw pixels)가 상태로 주어집니다.

00:04:57.506 --> 00:05:02.882
우리가 게임을 할 때 보이는 화면
그 자체가 상태인 것이죠

00:05:02.882 --> 00:05:09.912
에이전트의 행동은, 우리가 게임 플레이할 때 처럼
위, 아래, 좌, 우로 움직일 수 있습니다.

00:05:09.912 --> 00:05:15.667
매 스텝마다 게임 점수를 획를할 수도, 잃을 수도 있죠

00:05:15.667 --> 00:05:27.572
게임 종료 시점까지 점수를 최대화 하는 것이 목표입니다.
그리고 마지막으로 살펴볼 게임은 바로 "바둑" 입니다.

00:05:27.573 --> 00:05:31.697
지난해 강화학습이 이룬 가장 큰 성과라고 할 수 있습니다.

00:05:31.697 --> 00:05:38.588
세계 최고의 바둑기사였던 이세돌을 딥마인드의
알파고가 꺽은 엄청난 사건이 있었습니다.

00:05:38.589 --> 00:05:50.918
그리고 알파고는 최근에 또 다른 바둑
최강자들을 상대로 대국을 준비하고 있습니다.

00:05:50.919 --> 00:05:56.295
바둑에서는 게임에서 이기는 것이 목표입니다.
바둑을 둘 수 있는 모든 자리가 상태가 됩니다.

00:05:56.295 --> 00:06:03.911
행동은 다음 수를 두는 것이며
게임을 이겼을 경우에만 보상이 주어집니다.

00:06:03.912 --> 00:06:08.411
이에 대해서는 잠시 후에
자세히 살펴보도록 하겠습니다.

00:06:08.411 --> 00:06:13.329
그렇다면 강화학습 문제를 어떤 식으로
수학적으로 나타내 볼 수 있을까요?

00:06:13.330 --> 00:06:18.051
앞서 보았던 것 처럼 환경은
에이전트에게 상태를 부여합니다.

00:06:18.051 --> 00:06:20.634
그러면 에이전트는 행동을 취합니다.

00:06:22.394 --> 00:06:28.512
Markov Decision Process를 통해서
강화학습 문제를 수식화 시킬 수 있습니다.

00:06:28.512 --> 00:06:31.447
MDP는 Markov property를 만족합니다.

00:06:31.447 --> 00:06:36.107
Markov property란 현재 상태만으로
전체 상태를 나타내는 성질입니다.

00:06:36.107 --> 00:06:40.164
그리고 MDP는 여기 보시는 것과 같이
몇 가지 속성으로 정의가 되는데

00:06:40.164 --> 00:06:43.170
S는 가능한 상태들의 집합입니다.

00:06:43.170 --> 00:06:45.762
A는 가능한 행동들의 집합입니다.

00:06:45.762 --> 00:06:51.694
R은 (state, action) 쌍이 주어졌을 때 받게되는
보상의 분포가 되겠습니다.

00:06:51.694 --> 00:06:55.323
따라서 R은 (state, action)이 보상으로 매핑되는 함수입니다.

00:06:55.323 --> 00:06:57.430
P는 전이확률(transition probability) 입니다.

00:06:57.430 --> 00:07:02.940
(state, action) 쌍이 주어졌을때 전이 될
다음 상대에 대한 분포를 나타냅니다.

00:07:02.940 --> 00:07:05.718
마지막으로 감마는  discount factor입니다.

00:07:05.718 --> 00:07:12.970
discount factor는 보상을 받는 시간에 대해서
우리가 얼마나 중요하게 생각할 것인지 말해줍니다.

00:07:14.203 --> 00:07:17.395
MDP가 작동하는 방식을 한번 살펴보겠습니다.

00:07:17.395 --> 00:07:20.053
우선 초기 time step인 t = 0입니다.

00:07:20.053 --> 00:07:26.362
환경은 초기 초기 상태 분포인
p(s_0)에서 상태 s_0 를 샘플링합니다.

00:07:26.363 --> 00:07:32.253
그리고 t=0 에서부터 완료 상태가 될 때 까지
아래를 반복합니다.

00:07:32.253 --> 00:07:35.797
에이전트가 행동 a_t를 선택합니다.

00:07:35.797 --> 00:07:38.885
환경은 어떤 분포로부터 보상을 샘플링합니다.

00:07:38.885 --> 00:07:44.032
보상은 우리의 상태와 우리가 택한 행동이
주어졌을때의 보상입니다.

00:07:44.032 --> 00:07:51.534
환경은 다음 어떤 분포에서 상태인 s_t+1도 샘플링합니다.

00:07:51.534 --> 00:07:58.706
그리고 에이전트는 보상과 다음 상태를 받습니다.
그리고 다음 단계를 수행하게 됩니다.

00:07:58.707 --> 00:08:05.542
에이전트는 에피소트가 종료될 때 까지 이런 식으로
보상과 다음 상태를 받는 과정을 되풀이합니다.

00:08:05.542 --> 00:08:06.989
좋습니다.

00:08:06.989 --> 00:08:10.724
자 이제는 정책(polity) pi를 정의할 수 있습니다.

00:08:10.724 --> 00:08:16.651
정책은 각 상태에서 에이전트가 어떤 행동을 취할지를
명시해주는 기능을 수행합니다.

00:08:16.651 --> 00:08:19.748
정책은 deterministic 할수도
stochastic 할수도 있습니다.

00:08:19.748 --> 00:08:27.204
이제 우리의 목적은 최적의 정책 pi^star를 찾는 것입니다. 즉,
cumulative discounted reward를 최대화시키는 것입니다.

00:08:27.205 --> 00:08:35.508
보상에는 미래에 얻을 보상도 포함이 되는데 이 보상은
discount factor에 의해 할인된 보상을 얻습니다.

00:08:35.509 --> 00:08:39.327
자 그럼 아주 간단한 MDP 예제를 살펴보겠습니다.

00:08:39.327 --> 00:08:44.533
여기 예시로 격자로 된 Grid World가 있습니다.
이 곳에서 테스크를 수행해 봅시다.

00:08:44.533 --> 00:08:50.295
여기 격자 중 어디로든 이동할 수 있습니다.
우리의 상태가 될 것입니다.

00:08:50.295 --> 00:08:52.613
우리는 상태에 따라서 행동을 취할 수 있습니다.

00:08:52.613 --> 00:08:59.298
햄동은 간단한 움직임이 될 것입니다.
상,하,좌,우로 움직이는 행동을 취할 수 있겠죠

00:08:59.299 --> 00:09:08.858
여러분은 한번 움직일 때 마다 음의 보상
(negative reward)를 받게 됩니다.

00:09:08.859 --> 00:09:11.989
가령 R = -1 이 될 수도 있겠죠

00:09:11.989 --> 00:09:20.054
여러분의 목표는 여기 회색으로 칠해진 "종료
상태" 에 최소한의 행동으로 도달하는 것입니다.

00:09:20.055 --> 00:09:27.624
종료 상태에 도달하는 시간이 길어질수록
음의 보상이 점점 쌓이게 될 것입니다.

00:09:27.625 --> 00:09:30.540
그럼 random policy부터 살펴보겠습니다.

00:09:30.540 --> 00:09:39.089
random policy 에서는 기본적으로 어떤
방향로 움직이든 무작위로 방향을 결정합니다.

00:09:39.090 --> 00:09:41.843
모든 방향이 동일한 확률을 갖습니다.

00:09:41.843 --> 00:09:46.518
하지만 우리가 일련의 학습을 거쳐서 얻게될
optimal policy의 경우에는

00:09:46.518 --> 00:09:51.866
우리가 점점 더 종료 상태에 가까워 지도록 만드는
적절한 방향을 선택해서 행동을 취하게 됩니다.

00:09:51.866 --> 00:09:59.170
가령 종료 상태 바로 주변에 위치하는 경우라면
모든 방향은 종료 상태로 바로 이동하게끔 합니다.

00:09:59.171 --> 00:10:09.118
종료 상태와 먼 곳에 있다고 하더라도, 종료 상태에
가장 가깝게 이동할 수 있는 방향으로 이동합니다.

00:10:09.119 --> 00:10:17.154
이렇게 MDP를 정의하고 나면 최적의
정책인 pi^star를 찾아야 합니다.

00:10:17.155 --> 00:10:20.755
최적의 정책은 보상의 합을 최대화시킵니다.

00:10:20.755 --> 00:10:29.730
최적의 정책은 우리가 어떤 상태에 있더라도 그 상황에서
보상을 최대화시킬 수 있는 행동을 알려줍니다.

00:10:29.731 --> 00:10:34.091
자 그럼 질문은 "MDP에서 발생하는 무작위성(randomness)
을 어떻게 다뤄야 할까요?"

00:10:34.091 --> 00:10:39.073
가령 초기 상태를 샘플링할 시에도 무작위성이 있고

00:10:39.073 --> 00:10:46.340
전이 확률 분포의 경우에도 다음 상태가 확률적입니다.

00:10:46.341 --> 00:10:51.947
이를 위해서는 보상의 합에 대한 기댓값을 최대화시키면 됩니다.

00:10:51.947 --> 00:11:02.956
수식적으로 써보면, 최적의 정책 pi^star는 정책 pi에
대한 미래의 보상들의 합의 기댓값을 최대화시키는 것입니다.

00:11:02.957 --> 00:11:05.103
여기에서 초기 상태(s_0)는 어떤 상태 분포를 따르며

00:11:05.103 --> 00:11:09.127
우리가 취하는 행동은 어떤 상태가 주어졌을 때
정책이 가지는 분포로부터 샘플링됩니다.

00:11:09.127 --> 00:11:16.423
마지막으로 다음 상태는 전이 확률
분포로부터 샘플링됩니다.

00:11:16.423 --> 00:11:22.142
자 그럼 최적의 정책을 찾는 방법을 다루기 이전에

00:11:22.143 --> 00:11:26.787
앞으로 사용하게 될 몇 가지 정의부터 살펴보겠습니다.

00:11:26.787 --> 00:11:31.405
가치 함수(value function)와
Q-가치 함수(Q-value function)입니다.

00:11:31.405 --> 00:11:37.425
우리가 정책을 따라 무언가를 수행하게 되면 결국은
모든 에피소드마다 어떤 "경로" 를 얻게 될 것입니다.

00:11:37.426 --> 00:11:43.611
초기 상태인 s_0, a_0, r_0 부터 시작해서
s_1, a_1, r_1 이런식으로 쭉쭉 나가겠죠

00:11:43.611 --> 00:11:49.331
그렇게 되면 우리가 얻을 수 있는 상태(s), 행동(a), 보상(r)
들의 하나의 경로(trajectory)가 생깁니다.

00:11:49.331 --> 00:11:52.613
그렇다면 우리가 현재 속해있는
상태가 얼마나 좋은 상태일까요?

00:11:52.613 --> 00:12:10.799
임의의 상태 s에 대한 가치함수는 상태 s와 정책
pi가 주어졌을 때 누적 보상의 기댓값 입니다.

00:12:10.800 --> 00:12:13.286
그렇다면 (상태, 행동) 쌍이 얼마나 좋은지는
어떻게 알 수 있을까요?

00:12:13.286 --> 00:12:17.370
상태 s에서 어떤 행동 a를 취하는게 좋은 것일까요?

00:12:17.370 --> 00:12:20.468
우리는 이를 Q-가치 함수를 통해서 정의할 수 있습니다.

00:12:20.468 --> 00:12:27.741
Q-가치 함수는 정책 pi, 행동 a, 상태 s가 주어졌을 때
받을 수 있는 누적 보상의 기댓값입니다.

00:12:29.708 --> 00:12:45.098
최적의 Q-가치 함수인 Q^star는 (상태, 행동)
쌍으로부터 얻을 수 있는 누적 보상의 기댓값을 최대화시킵니다.

00:12:45.099 --> 00:12:52.017
다음으로는 강화학습에서 중요한 요소 중 하나인 벨만
방정식(Bellman equation)에 대해서 알아보겠습니다.

00:12:52.018 --> 00:12:57.697
우선 최적의 정책으로부터 나온 Q-가치 함수인
Q^star가 있다고 가정해봅시다.

00:12:57.697 --> 00:13:00.911
Q^star는 벨만 방정식을 만족할 것입니다.

00:13:00.911 --> 00:13:05.194
이것이 의미하는 바는

00:13:05.194 --> 00:13:11.748
어떤 (s, a)이 주어지던 간에

00:13:11.748 --> 00:13:18.867
현재 (s, a)에서 받을 수 있는 r 과 에피소드가
종료될 s^prime까지의 보상을 더한 값입니다.

00:13:18.868 --> 00:13:24.150
여기에서는 우리가 이미 최적의 정책을 알고 있기 때문에

00:13:24.150 --> 00:13:28.746
따라서 s^prime에서 우리가 할 수 있는
최상의 행동을 취할 수가 있습니다.

00:13:28.746 --> 00:13:34.432
s^prime에서의 Q^star의 값은
우리가 현재 상태에서 취할 수 있는 모든 행동들 중에

00:13:34.432 --> 00:13:38.626
Q^star(s^prime, a^prime) 을 최대화시키는 값이 됩니다.

00:13:38.626 --> 00:13:44.119
이를 통해서 최적의 Q 값을 얻을 수 있습니다.

00:13:44.119 --> 00:13:54.251
그리고 우리가 어떤 상태인지에 대한 무작위성이
존재하기 때문에 여기에도 기댓값을 취합니다.

00:13:54.252 --> 00:14:02.487
우리는 또한 Q^star를 통해서 특정 상태에서의 최상의
행동을 취할 수 있는 최적의 정책을 구할 수 있습니다.

00:14:02.488 --> 00:14:08.436
Q^star는 어떤 행동을 취했을때
미래에 받을 보상의 최대치입니다.

00:14:08.437 --> 00:14:16.862
따라서 우리는 그저 정책을 따라 행동을
취하기만 하면 최상의 보상을 받을 수 있습니다.

00:14:16.863 --> 00:14:21.025
그렇다면 어떻게 최적의 정책을 구할 수 있을까요?

00:14:21.025 --> 00:14:25.692
우리가 이 문제를 해결할 수 있는 한 가지 방법은 바로
value iteration algorithm 입니다.

00:14:25.692 --> 00:14:29.527
반복적인 업데이트를 위해서 벨만 방정식을 사용할 것입니다.

00:14:29.527 --> 00:14:37.997
Bellman equation을 통해 각 스텝마다 Q_star를
조금씩 최적화시키면 됩니다.

00:14:39.347 --> 00:14:50.830
수학적으로 보면 Q_i의 i가 무한대일때
최적의 Q_star로 수렴하게 됩니다.

00:14:54.257 --> 00:14:58.329
이 방법이 잘 동작하긴 할 겁니다.
하지만 문제가 있습니다. 무엇일까요?

00:14:59.184 --> 00:15:02.720
문제는 바로 이 방법은
scalable 않다는 점입니다.

00:15:02.720 --> 00:15:08.596
반복적으로 업데이트하기 위해서는 모든 (상태, 행동)
마다 Q(s)를 계산해야만 합니다.

00:15:08.597 --> 00:15:18.932
가령 Atati 게임의 경우 스크린에
보이는 모든 픽셀이 상태가 될 수 있습니다.

00:15:18.933 --> 00:15:28.724
이 경우 상태 공간이 아주 크며, 기본적으로
전체 상태 공간을 계산하는 것은 불가능합니다.

00:15:28.725 --> 00:15:35.907
해결책은 무엇일까요? 우선, 함수 Q(s, a)
를 근사시킬 수 있습니다.

00:15:35.908 --> 00:15:37.620
예를 들어 neural network를 사용할 수 있겠죠

00:15:37.620 --> 00:15:48.471
언제나 그러 했듯이, 우리가 모르는 아주 복잡한 함수를
추정하고 싶을때는 neural network가 제격입니다.

00:15:48.472 --> 00:15:54.242
그러면 이제 Q-learning 수식을 살펴보겠습니다.

00:15:54.242 --> 00:16:02.950
여기에서는 행동 가치 함수(action value
function)을 추정하기 위한 함수 근사를 이용할 것입니다.

00:16:02.951 --> 00:16:08.141
함수 근사로는 최근 가장 많이 사용되는
deep neural network를 이용할 것입니다.

00:16:08.142 --> 00:16:10.782
이를 deep Q-learning 이라고 합니다.

00:16:10.782 --> 00:16:20.149
Deep Q-learning은 요즘 강화학습
하면 빠지지 않고 등장하는 방법입니다.

00:16:20.150 --> 00:16:30.765
여기에서는 함수 파라미터 theta가 있습니다.
theta는 neural network의 가중치입니다.

00:16:33.050 --> 00:16:37.970
자 그럼 함수 근사를 이용해서
어떻 방식으로 최적의 정책을 찾아낼 수 있을까요?

00:16:37.970 --> 00:16:44.744
Q-function은 벨만 방정식을 만족해야 한다는 점을 명심해야 합니다.

00:16:44.744 --> 00:16:54.712
자 이제 우리 함수가 벨만 방정식을 만족하도록 해야 합니다. 해야할
일은 neural network로 근사시킨 Q-function을

00:16:54.713 --> 00:17:00.239
학습시켜서 벨만 방정식의 에러가
최소가 되도록 하면 됩니다.

00:17:00.240 --> 00:17:03.689
손실 함수는 q(s, a)가 목적 함수와 얼마나 멀리
떨어져있는지 측정합니다.

00:17:03.689 --> 00:17:09.853
여기 보이는 목적함수 y_i가 바로 앞서 살펴본
벨만 방적식이 되겠습니다.

00:17:09.853 --> 00:17:16.928
forward pass에서는 손실 함수를 계산합니다.
손실이 최소가 되면 좋겠죠

00:17:16.929 --> 00:17:28.182
backward pass에서는 계산한 손실을
기반으로 파라미터 theta를 업데이트합니다.

00:17:28.183 --> 00:17:38.435
이런 식의 반복적인 업데이트를 총해서 우리가 가진
Q-function이 타켓과 가까워지도록 학습시킵니다.

00:17:38.436 --> 00:17:43.524
질문 있나요?

00:17:44.537 --> 00:17:53.369
Deep Q-learning 방법이
적용된 고전적인 예제를 살펴보겠습니다.

00:17:53.370 --> 00:18:01.745
앞서 살펴본 Atrari game 입니다. 게임의
목적은 최대한 높은 점수를 획득하는 것입니다.

00:18:01.746 --> 00:18:05.460
상태는 게임의 픽셀이 그대로 사용되었습니다.

00:18:05.460 --> 00:18:12.963
행동은 상, 하, 좌, 우 와 같이
게임에 필요한 어떤 행동이 될 것입니다.

00:18:12.964 --> 00:18:21.182
게임이 진행됨에 따라 매 타임 스템마다 점수가
늘어나거나 줄어듦에 따라 보상을 얻습니다.

00:18:21.183 --> 00:18:27.095
스코어를 기반으로 전체 누적 보상을 계산할 수 있습니다.

00:18:27.095 --> 00:18:32.955
Q-function에 사용한 네트워크는 다음과 같이 생겼습니다.

00:18:32.955 --> 00:18:37.355
Q-network는 가중치인 theta를 가지고 있습니다.

00:18:37.355 --> 00:18:43.791
네트워크의 입력은 상태 s 입니다.
즉 현제 게임 스크린의 픽셀들이 들어옵니다.

00:18:43.791 --> 00:18:49.509
실제로는 4프레임 정도 누적시켜서 사용합니다.

00:18:49.509 --> 00:18:58.608
입력은 RGB->grayscale변환, 다운
샘플링, 크라핑 등 전처리 과정을 거칩니다.

00:18:58.609 --> 00:19:04.631
전처리를 거친 입력은 최근 4 프레임을 누적시킨
84 x 84 x 4 의 형태가 됩니다.

00:19:04.631 --> 00:19:05.464
질문 있나요?

00:19:05.464 --> 00:19:09.631
[학생이 질문]

00:19:12.792 --> 00:19:20.808
질문은 "네트워크가 다양한 (상태, 행동) 쌍들을 구하기
위해서 Q-가치 함수를 근사시키는 것인지" 입니다.

00:19:20.809 --> 00:19:24.765
(가령 이 예시의 경우 4개의 (상태, 행동)쌍을 출력)
네 맞습니다.

00:19:24.765 --> 00:19:27.551
이에 대해서는 다음 슬라이드에서
조금 더 자세히 설명할 것입니다.

00:19:27.551 --> 00:19:29.935
[학생이 질문]

00:19:29.935 --> 00:19:36.815
여기에서는 Softmax를 사용하지는 않습니다. Q-value
functions을 직접 예측하는 것이 목적입니다.

00:19:36.816 --> 00:19:40.582
[학생이 질문]

00:19:40.583 --> 00:19:44.014
Q-values를 regression 한다고 보시면 됩니다.

00:19:44.014 --> 00:19:54.083
입력 다음으로 살펴볼 것은 네트워크 구조인데, 우리에게는 아주
익숙한 구조입니다. 컨볼루션, FC 레이어들로 구성됩니다.

00:19:54.084 --> 00:19:59.610
8 x 8 / 4 x 4 컨볼루션이 있고

00:19:59.611 --> 00:20:05.673
그리고 FC 256 레이어를 거칩니다. 이제는
우리에게 아주 익숙한 네트워크 구조입니다.

00:20:05.674 --> 00:20:17.414
FC 레이어의 출력 벡터는 네트워크의 입력인, "상태"
가 주어졌을 때 각 행동의 Q-value 입니다.

00:20:17.415 --> 00:20:21.770
가령 네 가지 행동이 존재한다면
출력도 4차원입니다.

00:20:21.770 --> 00:20:28.685
이는 현재 상태 s_t와 여기에 존재하는 행동들
a_1, a_2, a_3, a_4에 관한 Q 값들입니다.

00:20:28.685 --> 00:20:33.179
각 행동들 마다 하나의 스칼라 값을 얻습니다.

00:20:33.179 --> 00:20:43.072
참고로 행동의 수는 Atari game의 종류에
따라서 4~18가지로 변할 수도 있습니다.

00:20:43.073 --> 00:20:46.709
이런 방식의 네트워크 구조의 장점은

00:20:46.709 --> 00:20:54.650
한 번의 forward pass 만으로 현재 상태에 해당하는
모든 함수에 대한 Q-value를 계산할 수 있다는 점입니다.

00:20:54.651 --> 00:20:56.117
이는 정말 효율적인 방법입니다.

00:20:56.117 --> 00:21:05.945
현재 상태의 각 행동들에 각각 Q-value가 존재할텐데
현재 상태를 네트워크의 입력으로 넣어주기만 하면

00:21:05.946 --> 00:21:10.259
모든 Q-value를 한번의 forward pass로 계산할 수 있습니다.

00:21:10.259 --> 00:21:15.078
이 네트워크를 학습시키 위해서는
앞서 살펴본 손실 함수가 필요합니다.

00:21:15.078 --> 00:21:17.661
네트워크로 근사시킨 함수도
벨만 방정식을 만족해야 합니다.

00:21:17.661 --> 00:21:29.314
따라서 네트워크의 출력인 Q-value가 타겟
값과 가까워 지도록 반복적으로 학습시켜야 합니다.

00:21:29.315 --> 00:21:40.705
backward pass에서는 손실함수를 기반으로
그레디언트를 계산하고 이를 바탕으로 네트워크를 학습시킵니다.

00:21:40.706 --> 00:21:45.639
한 가지 알아야 할 개념이 있습니다.
"experience replay" 라는 것입니다.

00:21:45.639 --> 00:21:53.440
Experience Replay는 Q-network에서
발생할 수 있는 문제들을 다룹니다.

00:21:53.440 --> 00:21:58.134
Q-network를 학습시킬 때 하나의 배치에서
시간적으로 연속적인 샘플들로 학습하면 안좋습니다.

00:21:58.134 --> 00:22:09.409
가령 게임을 진행하면서 시간적으로 연속적인 샘플들을
이용해서 상태, 행동, 보상을 계산하고 학습시키면

00:22:09.410 --> 00:22:16.117
모든 샘플들이 상관 관계를 가집니다(correlated). 이는
학습에 아주 비효율적입니다. 이 문제가 첫 번째 문제입니다.

00:22:16.118 --> 00:22:24.841
그리고 두번째로는, 현재 Q-network 파라미터를 생각해보면
네트워크는 우리가 어떤 행동을 해야할지에 정책을 결정한다는 것은

00:22:24.842 --> 00:22:27.394
우리가 다음 샘플들도 결정하게 된다는 의미입니다.

00:22:27.394 --> 00:22:30.832
이는 학습에 좋지 않은 영향을 미칠 것입니다.
(bad feedback loops)

00:22:30.832 --> 00:22:35.468
가령 현재 상태에서 "왼쪽" 으로 이동하는 것이
보상을 최대화하는 행동이라면

00:22:35.468 --> 00:22:43.305
결국 다음 샘플들도 전부 "왼쪽"에서
발생할 수 있는 것들로만 편향될 것입니다.

00:22:43.306 --> 00:22:45.406
이는 문제가 될 수 있습니다.

00:22:45.406 --> 00:22:53.097
이를 해결하는 방법으로 "experience
replay" 라는 방법을 사용합니다.

00:22:53.098 --> 00:23:01.352
이 방법은 replay memory를 이용합니다. replay memory에는
(상태, 행동, 보상. 다음상태)로 구성된 전이 테이블이 있습니다.

00:23:01.353 --> 00:23:08.772
게임 에피소드를 플레이하면서 더 많은 경험을 얻음에
따라 전이 데이블을 지속적으로 업데이트시킵니다.

00:23:08.773 --> 00:23:16.334
여기에서는 replay memory에서의 임의의 미니
배치를 이용하여 Q-network를 학습시킵니다.

00:23:16.335 --> 00:23:24.826
연속적인 샘플을 사용하는 대신 전이 테이블에서
임의로 샘플링된 샘플을 사용하는 것이죠.

00:23:24.827 --> 00:23:31.007
이 방식을 통해서 앞서 상관관계(correlation)로
발생하는 문제를 해결할 수 있을 것입니다.

00:23:31.007 --> 00:23:39.206
추가적인 이점으로는 각각의 전이가 가중치 업데이트에 여러
차례(딱 한번이 아니라) 기여할 수 있다는 점입니다.

00:23:39.207 --> 00:23:43.652
전이 테이블로부터 샘플링을 하면
하나의 샘플도 여러번  뽑힐 수 있는 것이죠

00:23:43.652 --> 00:23:47.585
이를 통해 데이터 효율이 훨씬 더 증가하게 됩니다.

00:23:50.580 --> 00:23:59.165
자 그럼 종합해서, experience replay를
이용한 Q-learning 전체 알고리즘을 살펴보겠습니다.

00:23:59.166 --> 00:24:03.940
우선  replay memory을 초기화하는 것부터 시작합니다.

00:24:03.940 --> 00:24:14.829
우선 memory capacity인 N을 정해줍니다.
그리고 Q-network를 임의의 가중치로 초기화시킵니다.

00:24:14.830 --> 00:24:21.832
그리고 앞으로 M번의 에피소드를 진행할 것입니다.
따라서 학습은 총 M번의 에피소드까지 진행됩니다.

00:24:21.832 --> 00:24:31.264
그리고 각 에피소드마다 상태를 초기화시켜야 합니다.
상태는 게임 시작화면 픽셀이 될 것입니다.

00:24:31.265 --> 00:24:37.814
앞서, 입력 상태를 만들기 위한
전처리 과정은 앞서 언급했었죠

00:24:37.814 --> 00:24:41.584
다음은, 게임이 진행중인
매 타음 스탭마다

00:24:41.584 --> 00:24:46.268
적은 확률로는 임의의 행동을 취할 것입니다.
(정책을 따르지 않고)

00:24:46.268 --> 00:24:53.141
이는 충분한 탐사(exploration)을 위해서는
아주 중요한 부분입니다.

00:24:53.141 --> 00:24:58.559
이를 통해 다양한 상태 공간을 샘플링할 수 있습니다.

00:24:58.559 --> 00:25:03.613
낮은 확률로 임의의 행동을 취하거나, 또는(otherwise)
현재 정책에 따라 greedy action을 취합니다.

00:25:03.614 --> 00:25:13.579
다시 말해 대부분의 경우에는 현재 상태에 적합하다고 판단되는
greedy action을 선택하게 될 것이고, 가끔식은

00:25:13.580 --> 00:25:16.300
낮은 확률로 임의의 행동이 선택될 것입니다.

00:25:16.300 --> 00:25:26.069
이렇게 행동 a_t를 취하면 보상(r_t)과
다음 상태(s_t+1)를 얻을 수 있습니다.

00:25:26.070 --> 00:25:32.771
그러고 나서 전이(transition)을
replay memory에 저장합니다.

00:25:32.771 --> 00:25:35.577
자 이제 네트워크를 학습시킬 차례입니다.

00:25:35.577 --> 00:25:37.550
experience replay를 이용할 시점입니다.

00:25:37.550 --> 00:25:47.213
replay memory에서 임의의 미니배치 전이들(transitions)을
샘플링한 다음에 이를 이용하여 업데이트합니다.

00:25:47.214 --> 00:25:49.635
이것이 전체 학습의 반복과정입니다.

00:25:49.635 --> 00:26:03.886
게임을 진행하는 동안에 experienced replay을 이용하여
미니배치를 샘플링하고, 이를 통해 Q-network를 학습시킵니다.

00:26:03.887 --> 00:26:20.910
Google DeepMind에서 Atari 게임 Breakout을
Q-learning으로 학습시키는 영상을 살펴보겠습니다.

00:26:20.911 --> 00:26:26.185
게임화면의 픽셀 그대로가 상태입니다.

00:26:26.185 --> 00:26:29.520
학습 초반에 어떤 일이 발생하는지 살펴봅시다.

00:26:29.520 --> 00:26:40.302
학습 초반에는, 공을 치긴 하지만 그렇게 잘해보이지는 않습니다.
금방 놓치고 맙니다.

00:26:40.303 --> 00:26:42.886
그래도 계속 공을 찾아다니고 있습니다.

00:26:50.969 --> 00:26:55.737
그리고 몇 시간정도 더 학습한 결과를 살펴봅시다.

00:27:00.946 --> 00:27:05.113
지금은 어느정도 잘 하는 것 같습니다.

00:27:06.190 --> 00:27:16.592
공도 잘 따라가고 있고 블럭도 거의 다 깨는 모습입니다.

00:27:16.593 --> 00:27:36.203
240분이 지나면 이제는 거의
프로에 가까운 묘기를 선보입니다.

00:27:36.203 --> 00:27:42.795
공을 위로 올려서 알아서 블럭이 깨지게 하는 전략이죠

00:27:42.796 --> 00:27:49.500
지금 보여드린 예시에서는 Agent가 deep Q-learning을
통해 Atari 게임을 학습하고 플레이하였습니다.

00:27:49.501 --> 00:27:56.418
온라인을 통해서 더 많은 Atrari
게임에서의 예시를 확인해보실 수 있습니다.

00:27:56.419 --> 00:28:01.149
지금까지 Q-learning을 알아봤습니다.
하지만 Q-learning에는 문제가 있었습니다.

00:28:01.149 --> 00:28:07.225
아주 어려운 문제였는데요, 그 문제는 바로
Q-function이 너무나도 복잡하다는 것입니다.

00:28:07.226 --> 00:28:12.335
Q-learning 에서는 모든 (state, action) 쌍들을
학습해야만 합니다.

00:28:12.335 --> 00:28:17.275
그런데 가령, 로봇이 어떤 문체를 손에 쥐는
문제를 풀어야 한다고 생각해봅시다.

00:28:17.275 --> 00:28:19.576
이 경우 아주 고차원의 상태 공간이 존재합니다.

00:28:19.576 --> 00:28:26.225
가령 로봇의 모든 관절의 위치와 각도가 이룰 수 있는
모든 경우의 수를 생각해볼 수 있겠죠

00:28:26.225 --> 00:28:35.492
이 모든 (state, action)을
학습시키는것은 아주 어려운 문제입니다.

00:28:35.493 --> 00:28:38.724
다른 한편으로는 "정책" 자체는 훨씬 더 간단할 수 있습니다.

00:28:38.724 --> 00:28:44.555
정책은 간단하게 "손을 움켜쥐는 것" 같이 말이죠

00:28:44.556 --> 00:28:48.252
손가락을 특정 방향으로 움직이기만 하면 됩니다.

00:28:48.252 --> 00:28:54.142
그렇다면 정책 자체를 학습시킬 수 있을까요?

00:28:54.142 --> 00:28:58.306
만약 가능하다면 여러 정책들 가운데
최고의 정책을 찾아낼 수 있을 것입니다.

00:28:58.306 --> 00:29:06.789
정책을 결정하기에 앞서 Q-value를
추정하는 과정을 거치지 않고도 말이죠

00:29:06.790 --> 00:29:15.937
이러한 접근 방식이
"policy gradients" 입니다.

00:29:15.938 --> 00:29:20.858
자 그럼 수식적으로 매개변수화된 정책 집합
(class of parametrized policies)을 정의해봅시다.

00:29:20.858 --> 00:29:24.146
정책들은 가중치 theta에 의해서 매개변수화됩니다.

00:29:24.146 --> 00:29:27.791
자 그럼 각 정책에 대해서
정책의 값을 정의해봅시다.

00:29:27.791 --> 00:29:35.722
J(theta)는 미래에 받을 보상들의
누적 합의 기댓값으로 나타낼 수 있습니다.

00:29:35.723 --> 00:29:38.971
이는 우리가 지금까지 사용했던
보상과 동일합니다.

00:29:38.971 --> 00:29:41.879
이런 상황(setup)에서 우리가 하고싶은 것은

00:29:41.879 --> 00:29:51.547
최적의 정책인 theta^star를 찾는 것인데 이는
argmax_theta J(theta)로 나타낼 수 있습니다.

00:29:51.548 --> 00:29:56.917
이제는 보상의 기댓값을 최대로 하는 정책
파라미터를 찾으면 됩니다.

00:29:56.917 --> 00:30:01.011
이 문제를 어떻게 풀면 될까요?

00:30:04.993 --> 00:30:10.155
policy parameter에 대해서
gradient ascent를 수행하면 될 것입니다.

00:30:10.155 --> 00:30:15.460
지금까지 배웠던 것 처럼 하면 되겠죠
gradient ascent를 통해서

00:30:15.460 --> 00:30:20.762
parameters를 연속적으로 업데이트해주면 됩니다.

00:30:23.202 --> 00:30:29.196
자 그럼 조금만 더 구체적으로 살펴보겠습니다.
REINFORCE 알고리즘을 한번 알아봅시다.

00:30:29.196 --> 00:30:36.781
수학적으로 보면, 경로에 대한 미래 보상의
기댓값으로 나타낼 수 있습니다.

00:30:36.781 --> 00:30:41.902
이를 위해서 경로를 샘플링해야 하는데, 가령 이는 앞선 예제에서
게임 플레이 시의 에피소드일 수 있습니다.

00:30:41.902 --> 00:30:47.411
s_0, a_0, r_0, s_1 등등 이 되겠죠

00:30:47.411 --> 00:30:51.723
이들은 어떤 정책 pi_theta을 따라 결정될 것입니다.

00:30:51.723 --> 00:30:57.739
그러면 각 경로에 대해서 보상을 계산할 수 있을 것입니다.

00:30:57.739 --> 00:31:01.245
이 보상은 우리가 어떤 경로를 따라 얻을
수 있는 누적 보상이 될 것입니다.

00:31:01.245 --> 00:31:10.570
따라서 정책인 pi_theta의 값은 샘플링 된 경로로 부터
받게 될 보상의 기댓값이 될 것입니다.

00:31:10.570 --> 00:31:16.868
따라서 여기에 이 기댓값은 우리가 정책으로 부터
샘플링한 경로들에 대한 기댓값입니다.

00:31:18.563 --> 00:31:21.288
자 그럼 gradient ascent를 수행해야 합니다.

00:31:21.288 --> 00:31:22.961
J(theta)를 미분해봅시다.

00:31:22.961 --> 00:31:27.356
미분을 하고나서 이 값들을
gradient step으로 취하면 될 것입니다.

00:31:28.535 --> 00:31:34.300
하지만 여기에도 문제가 있습니다. 미분을 잘 하긴 했는데
이 값을 계산할 수가 없습니다(intractable).

00:31:34.300 --> 00:31:41.319
p가 theta에 종속되어 있는 상황에서
기댓값 안에 그레디언트가 있으면 문제가 될 수 있습니다.

00:31:41.319 --> 00:31:47.661
여기에서 보면 p(tau ; thera)에 대한
그레디언트를 구해야하는데

00:31:47.661 --> 00:31:53.033
tau에 대한 적분을 수행해야 하기 때문에
계산하기기 어렵습니다.

00:31:53.033 --> 00:31:57.327
하지만 이를 해결하기 위한 트릭이 있습니다.

00:31:57.327 --> 00:32:04.941
이 트릭은 p를 가지고 하는 것인데
어짜피 1을 곱하면 상관없으므로

00:32:04.941 --> 00:32:10.286
위 아래에 p(tau ; theta)를 곱해줍니다.

00:32:10.286 --> 00:32:26.170
자 이제 아래 쪽 두 번째, 세 번째 수식을 보시면
이 둘은 동치(equvalent)입니다.

00:32:26.170 --> 00:32:32.741
왜냐하면 log(p)의 그레디언트는
(1 / p) * p의 그레디언트 이기 때문입니다.

00:32:33.808 --> 00:32:41.385
자 그럼 이 수식을 앞에 있던
그레디언트 식에 대입해 봅시다.

00:32:41.385 --> 00:32:43.426
자 이제 실제로 어떻게 보이는지를 살펴봅시다.

00:32:43.426 --> 00:32:52.187
이제는 log(p)에 대한 그레디언트를 모든 경로에 대한
확률과 곱하는 꼴이 되고, 이를 tau에 대해서 적분하는 꼴이 되기 때문에

00:32:52.187 --> 00:32:58.586
이는 다시 경로 tau에 대한 기댓값의 형식으로 바꿀 수 있습니다.

00:32:58.586 --> 00:33:02.751
처음에는 기댓값에 대한 그레디언트를 계산했지만

00:33:02.751 --> 00:33:06.823
이제는 그레디언트에 대한 기댓값으로 바꾼 셈입니다.

00:33:06.823 --> 00:33:13.817
이로 인해, 그레디언트를 추정하기 위해서
경로들 샘플링하여 사용할 수 있게 되었습니다.

00:33:14.712 --> 00:33:21.260
따라서 이제는 Monte Carlo 샘플링을 사용할 수 있습니다.
이것이 바로 REINFORCE의 주요 아이디어입니다.

00:33:23.624 --> 00:33:28.180
자 그럼 우리가 계산하려고 하는 식을 살펴보겠습니다.

00:33:28.180 --> 00:33:33.071
그렇다면 우리는 p(tau ; theta)를
전이확률을 모르는 채로 계산할 수 있을까요?

00:33:33.071 --> 00:33:38.466
자 우선  p(tau)는 어떤 경로에 대한 확률이 될 것입니다.

00:33:38.466 --> 00:33:45.821
이는 현재 (상태, 행동)이 주어졌을 때, 다음에 얻게될
모든 상태에 대해서 "전이확률"과

00:33:45.821 --> 00:33:52.232
"정책 pi로 부터 얻은 행동에 대한 확률"의 곱의 형태로 이루어집니다.

00:33:52.232 --> 00:33:58.441
따라서 이를 모두 곱하면 경로에 대한
확률을 얻어낼 수 있을 것입니다.

00:33:58.441 --> 00:34:10.389
그렇다면 log(p ; tau)의 경우를 보면 앞서 곱했던 것들이
모두 합의 형태로 바뀌게 될 것입 니다.

00:34:10.389 --> 00:34:18.161
자 그럼 log(p)를 theta에 대해서 미분하는 경우를 생각해 봅시다.

00:34:18.163 --> 00:34:22.850
여기 보면 첫 번째 항인 전이확률은
theta와 무관한 항입니다.

00:34:22.850 --> 00:34:28.709
theta와 관련이 있는 항은 오직 두번째 항인
log pi_theta(a_t | s_t) 항 뿐입니다.

00:34:29.675 --> 00:34:39.669
우리는 이를 통해서 전이확률은 전혀 상관하지 않아도
된다는 사실을 알 수 있습니다.

00:34:39.670 --> 00:34:46.421
다시 말해, 그레디언트를 계산할 때
전이확률은 필요하지 않습니다.

00:34:47.257 --> 00:34:57.264
따라서 우리는 어떤 경로  tau에 대해서도
그레디언트를 기반으로 J(thera)을 추정해 낼 수 있을 것입니다.

00:34:58.524 --> 00:35:02.220
지금까지는 하나의 경로만 고려했었지만

00:35:02.220 --> 00:35:07.188
기댓값을 계산하기 위해서는 여러 개의 경로를
샘플링할 수도 있을 것입니다.

00:35:09.248 --> 00:35:17.141
그레디언트 계산을 하기 위해서 지금까지
유도해본 것들을 한번 해석해 봅시다.

00:35:18.217 --> 00:35:25.226
어떤 경로로부터 얻은 보상이 크다면, 즉
어떤 일련의 행동들이 잘 수행한 것이라면

00:35:25.226 --> 00:35:29.434
그 일련들 행동들을 할 확률을 높혀줍니다.

00:35:29.434 --> 00:35:33.141
그 행동들이 좋았다는 것을 말해주는 것입니다.

00:35:33.141 --> 00:35:37.186
반면 어떤 경로에 대한 보상이 낮다면
해당 확률을 낮춥니다.

00:35:37.186 --> 00:35:40.747
그러한 행동들은 좋지 못한 행동이었으며 따라서
그 경로가 샘플링되지 못하도록 해야 합니다.

00:35:40.747 --> 00:35:50.980
여기 수식을 보시면 pi(a given s)는
우리가 취한 행동들에 대한 우도(likelihood) 입니다.

00:35:50.980 --> 00:36:03.575
파라미터를 조정하기 위해서 그레디언트를 사용할 것이고,
그레디언트는 우도를 높히려면 어떻게 해야 하는지를 알려줍니다.

00:36:03.575 --> 00:36:12.602
즉 우리가 받게될 보상, 즉 행동들이 얼마나 좋았는지에 대한
그레디언트를 통해 파라미터를 조정하는 것입니다.

00:36:14.561 --> 00:36:23.798
단순하게 말해서, 어떤 경로가 좋았으면
경로에 포함되었던 모든 행동이 좋았다는 것을 의미합니다.

00:36:23.798 --> 00:36:26.356
하지만 기댓값이 의해서 이 모든 것들이
averages out 됩니다.

00:36:26.356 --> 00:36:30.125
average out을 통해
unbiased extimator를 얻을 수 있고

00:36:30.125 --> 00:36:35.622
충분히 많은 샘플링을 한다면 그레디언트를 잘 이용해서
정확하고 좋은 extimater를 얻을 수 있을 것입니다.

00:36:35.622 --> 00:36:42.994
이 방법이 좋은 이유는 그레디언트만 잘 계산한다면
손실 함수를 작게 만들 수 있고

00:36:42.994 --> 00:36:48.602
정책 파라미터 theta에 대한 (적어도) local optimum
을 구할 수 있기 때문엡니다.

00:36:48.602 --> 00:36:54.884
하지만 여기에도 문제가 존재합니다.
문제의 원인은 바로 바로 높은 분산에 있습니다.

00:36:54.884 --> 00:36:57.201
왜냐하면 신뢰할당문제(credit assignment)가
아주 어렵기 때문입니다.

00:36:57.201 --> 00:37:04.412
일단 보상을 받았으면  해당 경로의 모든
행동들이 좋았다 라는 정보만 알려줄 것입니다.

00:37:04.412 --> 00:37:11.080
하지만 우리는 구체적으로 어떤 행동이 최선이었는지를
알고 싶을 수도 있지만, 이 정보는 average out 됩니다.

00:37:11.080 --> 00:37:17.190
하지만 구체적으로 어떤 행동이 좋았는지 알 길이 없으며,
좋은 estimateor를 위해서는 샘플링을 충분히 하는 수 밖에 없습니다.

00:37:17.190 --> 00:37:23.851
이 문제는 결국 분산을 줄이고 estimator의 성능을 높이기 위해서는
어떻게 해야 하는지에 관한 질문으로 귀결됩니다.

00:37:26.540 --> 00:37:33.323
분산을 줄이는 것은 policy gradient 에서
아주 중요한 분야입니다.

00:37:33.323 --> 00:37:39.756
샘플링을 더 적게 하면서도 estimator의
성능을 높힐 수 있는 방법이기도 합니다.

00:37:39.756 --> 00:37:43.278
이를 해결할 수 있는 몇 가지 아이디어를 소개해 드리겠습니다.

00:37:44.202 --> 00:37:46.764
주어진 그래디언트 추정기를 보면,

00:37:46.764 --> 00:37:57.091
첫번째 아이디어는, 해당 상태로부터 받을 미래의 보상만을
고려하여 어떤 행동을 취할 확률을 키워주는 방법입니다.

00:37:57.091 --> 00:38:04.736
이 방법은 해당 경로에서 얻을 수 있는
전체 보상을 고려하는 것 대신에

00:38:04.736 --> 00:38:12.108
맨 처음부터가 아닌,  현재의 time step에서 부터 종료 시점까지
얻을 수 있는 보상의 합을 고려하는 것입니다.

00:38:12.108 --> 00:38:18.999
이 방법이 의도하는 바는 어떤 행동이 발생시키는
미래의 보상이 얼마나 큰지를 고려하겠다는 것입니다.

00:38:18.999 --> 00:38:20.499
그럴듯한 방법이죠

00:38:21.811 --> 00:38:29.448
두번째 아이디어는 지연된 보상에 대해서
할인률을 적용하는 것입니다.

00:38:29.448 --> 00:38:36.774
수식을 보시면 할인율이 추가되었습니다.
예전에도 봤었죠.

00:38:36.774 --> 00:38:47.276
할인율이 의미하는 것은. 당장 받을 수 있는 보상과
조금은 더 늦게 받은 보상간의 차이를 구별하는 것입니다.

00:38:47.276 --> 00:38:57.489
두번째 방법은 어떤 행동이 좋은 행동인지 아닌지를
해당 행동에 가까운 곳에서 찾습니다.

00:38:57.489 --> 00:39:00.880
나중에 수행하는 행동에 대해서는
가중치를 조금 낮추는 거죠

00:39:00.880 --> 00:39:07.730
이 두가지 방법은 실제로도 일반적으로 많이
사용하기도 하는 아주 쉬운 아이디어입니다.

00:39:07.730 --> 00:39:14.597
분산을 줄이기 위한 세번째 아이디어는
baseline이라는 방법입니다.

00:39:14.597 --> 00:39:20.690
경로에서부터 계산한 값을
그대로 사용하는 것은 문제가 있습니다.

00:39:21.675 --> 00:39:23.869
그런 값들 자체가 반드시 의미있는 값은 아닐 수도 있기 때문입니다.

00:39:23.869 --> 00:39:29.835
가량 보상이 모두 양수(positive)이기만 해도
행동들에 대한 확률이 계속 커지기만 할 것입니다.

00:39:29.835 --> 00:39:32.039
물론 그것이 나름대로 의미가 있을 순 있지만

00:39:32.039 --> 00:39:39.753
정말 중요한 것은 얻은 보상이 우리가 얻을 것이라고
예상했던 것 보다 더 좋은지, 아닌지를 판단하는 것입니다.

00:39:39.753 --> 00:39:46.071
이를 다루기 위해서 baseline function을 사용할 수 있습니다.
이 방법은 상태를 이용하는 방법입니다.

00:39:46.071 --> 00:39:53.886
baseline 함수가 말하고자 하는 것은 해당 상태에서
우리가 얼마 만큼의 보상을 원하는지 입니다(기준).

00:39:55.515 --> 00:39:59.837
그렇게 되면 확률을 키우거나 줄이는 보상 수식이 조금 바뀌게 되는데

00:39:59.837 --> 00:40:05.508
이를 수식에 적용하면 미래에 얻을 보상들의 합을
특정 기준이 되는 값(baseline)에서 값을 빼주는 형태가 되며

00:40:05.508 --> 00:40:10.772
이를 통해 우리가 기대했던 것에 비해 보상이 좋은지,
아닌지에 대한 상대적인 값을 얻을 수 있습니다.

00:40:11.870 --> 00:40:16.099
그렇다면 baseline을 어떻게 선택하면 좋을까요?

00:40:16.099 --> 00:40:19.168
가장 단순한 baseline은

00:40:19.168 --> 00:40:23.013
지금까지 경험했던 보상들에 대해서
moving average를 취하는 것입니다.

00:40:23.013 --> 00:40:34.765
에피소드를 수행하는 학습 과정에서 지금까지 봤던 모든 경로들에
대해서  보상이 어땠는지에 대한 평균을 내는 것입니다.

00:40:34.765 --> 00:40:41.716
이 아이디어를 이용해서 현재 보상이 상대적으로
좋은지 나쁜지를 알 수 있습니다.

00:40:42.821 --> 00:40:54.452
우리가 지금까지 배운 variance reduction 방법을
통상적으로 "vanilla REINFORCE" 라고 부릅니다.

00:40:54.452 --> 00:41:00.954
할인율을 적용하여 미래에 받을 보상을 누적시키고
여기에 단순한 baseline 을 추가하는 방식이죠

00:41:02.601 --> 00:41:08.769
자 그럼 이제는 baseline의 주요 아이디어와
더 좋은  baseline을 선택하는 방법에 대해서 살펴보겠습니다.

00:41:08.769 --> 00:41:13.567
우선 더 좋은 baseline이란 무엇인지 부터 생각해봅시다.

00:41:13.567 --> 00:41:24.255
우선 우리는 어떤 행동이 그 상태에서의 기댓 값 보다 좋은 경우에는
해당 상태에서 그 행동을 수행할  확률이 크길 원할 것입니다.

00:41:24.255 --> 00:41:30.163
자 그럼 그 "상태"로부터 기대할 수 있는 값이라면
여러분은 어떤 것이 생각나십니까?

00:41:30.163 --> 00:41:34.939
힌트는 우리가 앞서 한번 다룬 것입니다.

00:41:37.023 --> 00:41:41.297
[학생이 대답]
네 맞습니다. 가치 함수입니다.

00:41:41.297 --> 00:41:47.871
Q-learning에서 다뤘던 바로 그 가치함수입니다.
Q-function과 가치 함수를 이용해 볼 것입니다.

00:41:47.871 --> 00:41:58.173
여기에서의 직관은 우리가 어떤 상태 s에서 어떤 행동을 취했을때,
어떤 조건을 만족하면 그 행동이 좋았다고 판단하는 것입니다.

00:41:58.173 --> 00:42:04.752
그 조건은, 어떤 상태에서 특정 행동을
했을때 얻을 수 있는 Q-value가

00:42:04.752 --> 00:42:09.698
그 상태에서 얻을 수 있는 미래에 받을 수 있는 누적 보상들의
기댓 값이라는 가치함수 보다 더 큰 경우를 의미합니다.

00:42:09.698 --> 00:42:14.416
이는 그 행동이 우리가 선택하지 않은 다른
행동들보다 더 좋았다는 것을 의미합니다.

00:42:14.416 --> 00:42:22.063
반대로 그 차이 값이 음수거나 작은 경우에는
안 좋은 행동을 취했다는 것을 의미하는 것이겠죠

00:42:23.917 --> 00:42:34.868
이를 다시 estimator의 수식에 적용해 보겠습니다.

00:42:34.868 --> 00:42:40.168
수식 자체는 기존과 동일합니다.  다만

00:42:40.168 --> 00:42:50.514
앞선 수식에서는 variation reduction 기법과
baseline만 추가된 형태였다면, 지금은

00:42:50.514 --> 00:43:00.530
현재 행동이 얼마나 좋은 행동이었는지를 해당 상태에서의
Q-function 과 value function의 차이를 통해 나타냅니다.

00:43:01.771 --> 00:43:09.413
하지만 우리가 지금까지 살펴본 REINFORCE 알고리즘에서는
Q-function과 Value-function을 구하지 않았습니다.

00:43:09.413 --> 00:43:14.479
그렇다면 이를 학습시킬 수 있을까요?
정답은 '그렇다' 입니다. Q-learning을 통해서 말입니다.

00:43:14.479 --> 00:43:16.465
Q-learning은 이미 앞서 다뤘던 내용입니다.

00:43:16.465 --> 00:43:22.210
우리는 policy gradient와 Q-learning을 조합해서
이를 학습시킬 수 있습니다.

00:43:22.210 --> 00:43:28.784
여기에서는 actor 가 policy이고
critic이 Q-function 입니다.

00:43:28.784 --> 00:43:34.380
이들은 어떤 상태가 얼마나 좋은지, 그리고 상태에서의
어떤 행동이 얼마나 좋았는지를 말해줍니다.

00:43:34.380 --> 00:43:40.633
Actor-Critic 알고리즘에서
actor는 어떤 행동을 취할지를 결정합니다.

00:43:40.633 --> 00:43:47.708
그리고 critic (Q-function)은 그 행동이 얼마나 좋았으며
어떤 식으로 조절해 나가야하는지를 알려줍니다.

00:43:47.708 --> 00:43:53.636
그리고 critic의 Q-learning은 기존의 방법보다는
조금 완화된 임무를 수행합니다.

00:43:53.636 --> 00:43:59.958
기존의 Q-learning 에서는 모든 (상태, 행동) 쌍에 대한
Q-value 를 학습해야만 했습니다.

00:43:59.958 --> 00:44:04.762
하지만 여기에서는 policy가 만들어낸
(상태, 행동) 쌍에 대해서만 학습을 시키면  됩니다.

00:44:04.762 --> 00:44:10.512
계산이 필요한 곳에 어딘지만 알면 그만입니다.

00:44:10.512 --> 00:44:18.188
그리고 여기에서도 Q-function을 학습시킬 때, experience
replay와 같은 다양한 학습 전략을 추가할 수 있습니다.

00:44:18.188 --> 00:44:24.610
그리고 잠시 앞서 다뤘던 수식들을
새롭게 정의하고 넘어가겠습니다.

00:44:24.610 --> 00:44:38.172
이제는 Q(s, a) - V(s) 를 보상함수
(advantage function) 으로 나타낼 것입니다.

00:44:38.172 --> 00:44:43.568
즉 보상함수는 어떤 행동을 했을때 얼마나 많은
보상이 주어지는지를 나타냅니다.

00:44:43.568 --> 00:44:48.100
행동이 예상했던 것 보다 얼마나 더 좋은지를 나타내는 것이죠

00:44:48.100 --> 00:44:53.457
자 그럼 이를 이용해서 actor-critic 전체
알고리즘을 나타내 볼 수 있을 것입니다.

00:44:53.457 --> 00:44:56.279
자 그럼 어떻게 진행하는지를 살펴봅시다.

00:44:56.279 --> 00:45:03.689
우선은 policy parameter theta와
critic parameter phi를 초기화시킵니다.

00:45:03.689 --> 00:45:11.306
그리고 매 학습 interation 마다 현재의 정책을 기반으로
 M개의 경로를 샘플링합니다.

00:45:12.185 --> 00:45:18.725
policy에 기반해서 경로인 (s_0, a_0, r_0, s_1 ...)
를 뽑아내는 것입니다.

00:45:18.725 --> 00:45:21.671
그 다음 단계는 그레디언트를 계산하는 단계입니다.

00:45:21.671 --> 00:45:33.465
각 경로마다 보상 함수를 계산할 것입니다.
그리고 그 보상함수를 이용합니다.

00:45:33.465 --> 00:45:42.894
보상함수를 이용해서 gradient estimator를 계산하고
이를 전부 누적시킵니다.

00:45:42.894 --> 00:45:50.837
우리는 또한 critic parameter인
phi 또한 학습시켜야 합니다.

00:45:50.837 --> 00:45:57.557
이를 위해서는 가치 함수를 학습시켜야 하는데

00:45:57.557 --> 00:46:10.347
이는 보상 함수를 최소화 시키는 것과 동치(equivalent) 입니다.
이를 통해 가치 함수가 벨만 방정식에 근사하도록 학습시킬 수 있습니다.

00:46:10.347 --> 00:46:19.361
이런 식으로 poliy function(actor)과
critic function을 반복적으로 학습시킵니다.

00:46:20.211 --> 00:46:26.727
반복적으로 그레디언트를 업데이트하면서 학습을 진행합니다.

00:46:29.271 --> 00:46:31.827
자 그럼 REINFORCE를 활용한 몇 가지 예제를 살펴보겠습니다.

00:46:31.827 --> 00:46:39.464
우선은 Recurrent Attention Model (RAM)이 있습니다.

00:46:39.464 --> 00:46:49.146
hard attention 와도 관련이 있는 방법인데
요즘 컴퓨터 비전 분야에서 아주 핫합니다.

00:46:49.146 --> 00:46:59.167
우선 hard attention에 대해서 먼저 말씀드리겠습니다.
image classification 과 관련이 있는데

00:46:59.167 --> 00:47:06.494
여기에서도 이미지의 클래스를 분류하는 문제이긴 하지만
이미지의 일련의 glimpses를 가지고만 예측해야 합니다.

00:47:06.494 --> 00:47:10.300
이미지 전체가 아닌 지역적인 부분만을 보는 것이며

00:47:10.300 --> 00:47:17.141
어떤 부분을 볼지를 선택적으로 집중할 수 있으며
그렇게 살펴보면서 정보를 얻어나가는 것입니다.

00:47:17.141 --> 00:47:24.551
이런 식의 접근을 하는 이유는 우선 인간의 안구 운동에 따른
지각 능력으로부터의 영감이 있습니다.

00:47:24.551 --> 00:47:29.225
가령 우리가 복잡한 이미지를 보고 있고 이 이미지가
어떤 이미지인가를 알아내야 할 때

00:47:29.225 --> 00:47:39.168
처음에는 저해상도(low-resolution)로 살펴본 다음에
점점 더 세부적인 것들을 들여다 보게 되겠죠

00:47:39.168 --> 00:47:49.276
두번째로, 이런 식으로 이미지의 지역적인 부분만 살펴보는 방법은
계산 자원(computational resources)를 절약할 수 있습니다.

00:47:50.435 --> 00:47:53.293
이미지 전체를 전부 처리할 필요가 없겠죠

00:47:53.293 --> 00:48:03.576
우선 저해상도 살펴보면서 어디서부터 시작할 지 정하고
고해상도로 세부적인 것들을 찾아내는 방식이기대문입니다.

00:48:04.671 --> 00:48:15.177
이로 인해 계산 자원을 절약할 수 있으며, 크기가 큰 이미지들을
더 효과적으로 처리할 수 있는 scalability을 가질 수 있습니다.

00:48:16.164 --> 00:48:20.099
그리고 마지막으로 이 방법은 실제로
classification 성능을 높혀주기도 합니다.

00:48:20.099 --> 00:48:24.760
이 방법을 사용하면 필요없는 부분은 무시할 수 있기 때문입니다.

00:48:24.760 --> 00:48:29.931
ConvNet에 이미지 전체를 집어 넣는 것이 아니라

00:48:29.931 --> 00:48:36.353
ConvNet으로 실제로 내가 처리하고 싶은 부분만을
잘 선택할 수 있을 것입니다.

00:48:37.237 --> 00:48:41.531
그렇다면 이 문제를
강화학습 수식으로 나타내 보겠습니다.

00:48:41.531 --> 00:48:51.117
우선 상태(state)는 지금까지 관찰한 glimpses 입니다.
우리가 지금까지 얻어낸 정보라고 할 수도 있겠죠

00:48:51.117 --> 00:48:55.228
행동(action)은 다음에 이미지 내에 어떤
부분을 볼지를 선택하는 것입니다.

00:48:55.228 --> 00:49:02.842
실제로는 다음 스텝에서 보고 싶은 고정된 사이즈의
glimpse의 중간 x-y 좌표가 될 수 있습니다.

00:49:02.842 --> 00:49:12.423
강화학습에서 분류 문제를 풀때 보상은 최종스텝에서 1인데
이미지가 올바르게 분류되면 1, 그렇지 않으면 0입니다.

00:49:14.495 --> 00:49:24.550
이 문제에서 강화학습이 필요한 이유는 이미지에서 glimpses를
뽑아내는 것은 미분이 불가능한 연산이기 때문입니다.

00:49:25.761 --> 00:49:31.792
어떻게 glimpse를 얻어낼 것인지를 정책을 통해 학습하는 것입니다.
REINFORCE를 통해서 학습시킬 수 있습니다.

00:49:31.792 --> 00:49:40.891
누적된 glimpses가 모델에 주어지고
여기에서는 상태를 모델링하기 위해서 RNN을 이용합니다.

00:49:40.891 --> 00:49:47.418
그리고 policy parameters를 이용해서
다음 액션을 선택하게 됩니다.

00:49:49.354 --> 00:49:54.571
자 그럼 모델이 어떻게 생겼는지 살펴봅시다.
우선 입력 이미지가 들어옵니다.

00:49:54.571 --> 00:50:03.184
그리고 이미지에서 glimpse를 추출합니다. 여기에서는
여기 빨간색 박스가 glimpse인데 이 경우에는 비어있습니다.

00:50:03.184 --> 00:50:12.193
그리고 추출된 glimpse는 neural network를 통과합니다.
모델은 테스크에 따라 어떤 모델이든 가능합니다.

00:50:12.193 --> 00:50:18.758
논문의 실험에서는 MNIST를 사용했는데, MNIST는 단순한
데이터셋이라서 몇 개의 작은 FC-layers로 충분할 것입니다.

00:50:18.758 --> 00:50:26.105
만일 조금 더 복잡한 이미지 데이터셋이 있다면
fancier ConvNets을 고려하는 것도 좋은 방법입니다.

00:50:26.105 --> 00:50:28.775
glimpse를 neural entwork에 통과시키고 나면

00:50:28.775 --> 00:50:36.115
앞서 말씀드렸듯이 RNN을 이용해서 지금까지 있었던
glimpses를(state) 전부 결합시켜 줘야 합니다.

00:50:36.115 --> 00:50:40.265
이 과정은 잠시 후에 다시한번 알아보겠습니다.

00:50:40.265 --> 00:50:46.094
Neural network의 출력은 x-y 좌표 입니다.

00:50:46.094 --> 00:50:50.766
실제로는 출력 값이 행동에 대한 분포의 형태인데

00:50:50.766 --> 00:50:57.282
이 분포는 가우시안 분포를 따르며
결국 출력 값은 분포의 평균이 될 것입니다.

00:50:57.282 --> 00:51:03.944
평균과 분산을 모두 출력하는 경우도 있고
분산은 고정된 값으로 설정하기도 합니다.

00:51:03.944 --> 00:51:11.854
자 그럼 이 행동 분포로부터 특정 x, y
위치를 샘플링한 다음에

00:51:11.854 --> 00:51:17.777
이 x-y 좌표를 이용해서 다음 glimpse 를 얻어냅니다.

00:51:17.777 --> 00:51:23.385
새로운 glimpse를 보시면 숫자 2의 꼬리 부분으로
이동할 것을 볼 수 있습니다.

00:51:23.385 --> 00:51:26.745
이제야 비로서 모델이 우리가 원하는 부분을
보기 시작한 것 같습니다.

00:51:26.745 --> 00:51:32.724
우리가 원하던건 모델이 이미지에서 classification에
유용한 부분을 보길 원했으니까요

00:51:32.724 --> 00:51:37.104
그리고 다시 새롭게 추출한 glimpse를
neural network에 통과시킵니다.

00:51:38.153 --> 00:51:47.343
그리고 현재 입력과 이전 상태(previous hidden state)
를 입력으로 받는 RNN을 이용해서 policy를 모델링 할 것입니다.

00:51:47.343 --> 00:51:54.095
이 RNN 모델은 다음 위치의 glimpse에 대한 분포를 출합니다.

00:51:54.095 --> 00:51:57.303
이 작업을 반복합니다.
다음 glimpse는 여기군요

00:51:57.303 --> 00:51:59.903
기존보다 숫자 2의 중앙으로 조금 더 움직였습니다.

00:51:59.903 --> 00:52:14.543
아마 이 모델은 숫자 2의 꼬리 부분을 봤으면 조금 더 의미있는
정보를 얻기 위해 좌상단으로 이동하도록 학습된 것 같습니다.

00:52:14.543 --> 00:52:17.473
이를 계속 반복해줍니다.

00:52:17.473 --> 00:52:26.795
그리고 마지막 타입 스텝에 도달하게 됩니다. 타임스텝의 수는
고정된 값을 주로 사용합니다. 실제로는 6-8번 정도를 사용합니다.

00:52:26.795 --> 00:52:33.350
그리고 마지막 타임 스텝에서는, 결국 우리는
분류를 하고싶기 때문에

00:52:33.350 --> 00:52:39.363
Softmax를 통해서 각 클래스 확률분포를
출력하도록 합니다.

00:52:39.363 --> 00:52:44.108
가령 이 경우에는 가장 높은 확률의 클래스가 2이고
결국 모델이 숫자를 2라고 잘 예측할 수 있었습니다.

00:52:44.108 --> 00:52:50.428
자 여기까지는 모델과 정책이 어떻게 이루어졌는지를 살펴보있습니다.

00:52:50.428 --> 00:52:59.569
그레디언트를 구하는 법은 기존과 동일합니다. 이 모델로부터
경로를 샘플링하고 그레디언트를 계산해서 backprob를 진행합니다.

00:52:59.569 --> 00:53:08.698
REINFORCE 알고리즘을 통해서 모델과
정책 파라미터를 학습시킬 수 있을 것입니다.

00:53:09.953 --> 00:53:15.257
MNIST로 학습시킨 예시입니다.

00:53:16.710 --> 00:53:27.685
결과를 보시면 어느 지점에서 시작하던지 점점 숫자의 위치에
가까워지는 것을 보실 수 있습니다. 아주 멋진 결과입니다.

00:53:27.685 --> 00:53:30.460
우리가 기대하던 바입니다.

00:53:30.460 --> 00:53:38.400
만일 여러분이 어떤 숫자인지 알기 위해 다음에 볼 가장
효과적인 곳을 고른다고 해도 비슷할 것입니다.

00:53:40.108 --> 00:53:49.758
Hard attention이라는 아이디어는 지난 몇 년간
다양한 컴퓨터문제를 푸는데 사용되었습니다.

00:53:49.758 --> 00:53:54.790
가령 fine-grained image recognition
같은 문제에 사용할 수 있습니다.

00:53:54.790 --> 00:54:01.763
그리고 앞서 말씀드렸듯이 이 방법의 이점으로는

00:54:02.975 --> 00:54:10.180
계산 효율이 좋다는 점과 이미지 내의
불필요한 정보들을 무시할 수 있다는 점입니다.

00:54:10.180 --> 00:54:13.092
만일 여러분이 fine-grained image classification
문제를 풀고자 한다면 이 두마리 토끼를 다 잡고 싶을 것입니다.

00:54:13.092 --> 00:54:25.777
고해상도를 유지하여 중요한 특징들을 잘 보존하면서도
불필요한 부분들은 무시하고 싶은 그런 상황일때 말이죠

00:54:25.777 --> 00:54:27.359
질문있나요?

00:54:27.359 --> 00:54:31.526
[학생이 질문]

00:54:35.061 --> 00:54:41.482
질문은 "RNN 모델이 들어가는데, 계산이
효율적일 수 있는지" 입니다.

00:54:41.482 --> 00:54:47.761
네 맞습니다. 사실 계산 효율과 관련된 문제는 여러분이
어떤 문제를 풀고 어떤 네트워크를 선택했는지 등에 달려있습니다.

00:54:47.761 --> 00:54:52.512
가령 여러분이 아주 고해상도의 이미지가 있다고 해봅시다.

00:54:52.512 --> 00:55:01.900
여러분은 이 이미지 전체를 처리하고 싶지 않을 수도 있습니다.
이 이미지를 처리하려면 아주 큰 네트워크가 필요할 수도 있습니다.

00:55:01.900 --> 00:55:04.669
이미지의 특정 일부분에만 집중한다면
어느정도 계산량을 절약할 수 있을 것입니다.

00:55:04.669 --> 00:55:06.589
이미지 일부만 처리한다면 말이죠

00:55:06.589 --> 00:55:10.924
그렇긴 하지만 결국은 어떤 문제냐에 달려있습니다.

00:55:12.210 --> 00:55:14.530
REINFORCE 알고리즘은
이미지 캡셔닝에도 사용할 수 있습니다.

00:55:14.530 --> 00:55:17.138
어떤 이미지에 대한 캡션을 만드는 상황에서

00:55:17.138 --> 00:55:23.197
이런 류의 attention model을 이미지에 사용할 수 있을 것입니다.

00:55:23.197 --> 00:55:28.999
정책을 이미지의 특정 부분에 집중하도록 학습시키고

00:55:28.999 --> 00:55:38.341
이미지의 특정 부분에 집중하면서 그 부분에 적절한
캡션을 생성할 수 있도록 하는 방법입니다.

00:55:38.341 --> 00:55:42.948
그리고 visual question answering(VQA)
문제를 풀어볼 수도 있습니다.

00:55:42.948 --> 00:55:51.786
이미지에 대해 질문을 하면 모델은 적절한 답변을 해야 합니다.
저는 잘 모르지만, 가령

00:55:51.786 --> 00:55:53.840
테이블 주변에 의자가 몇 개 있습니까? 와 같은 질문들입니다.

00:55:53.840 --> 00:56:03.040
attention mechanism을 이용하면 그러한 모델이 그러한
질문에 잘 답변할 수 있도록 학습시킬 수 있을 것입니다.

00:56:05.707 --> 00:56:10.564
지금까지는 policy gradient를 활용한
hard attention models의 예시를 살펴봤습니다.

00:56:10.564 --> 00:56:16.430
예시를 하나 더 살펴볼 것입니다.
이 또한 policy gradient를 이용한 방법입니다.

00:56:16.430 --> 00:56:18.465
바둑을 학습시키는 모델입니다.

00:56:18.465 --> 00:56:24.497
DeepMind에는 AlphaGo 라고 하는
바둑을 두는 에이전트가 있습니다.

00:56:24.497 --> 00:56:30.708
몇 해 전부터 뉴스에도 아주 많이 나왔습니다.

00:56:30.708 --> 00:56:31.541
질문있나요?

00:56:31.541 --> 00:56:32.374
[학생이 질문]

00:56:32.374 --> 00:56:39.258
네 어제에도 (뉴스가) 있었습니다.
아주 흥미로운 뉴스였죠

00:56:39.258 --> 00:56:57.886
지난 해, AlphaGo v1과 이세돌과의 대국이 있었습니다.
5번의 대국 중 4:1로 AlphaGo가 승리했었죠

00:56:57.886 --> 00:57:09.348
현재 AlphaGo는 커제(Ke Jie)와의
3선승제 대국을 진행중입니다.

00:57:09.348 --> 00:57:13.436
첫 대국이 어제 있었고
AlphaGo가 승리했습니다.

00:57:13.436 --> 00:57:20.657
첫 대국에서는 AlphaGo가 0.5점 앞서 승리를 거두었습니다.
두 경기가 남았고, 라이브 스트리밍을 지원하니

00:57:20.657 --> 00:57:28.193
온라인으로 시청해 보시는 것도 좋을 것입니다.
해설을 들으면서 보면 상당히 재밌습니다.

00:57:29.225 --> 00:57:32.577
그러면 DeepMind의 AlphaGo는 무엇일까요?

00:57:32.577 --> 00:57:36.466
AlphaGo의 많은 부분은 우리가 이번 시간에
다룬 것들을 기반으로 합니다.

00:57:36.466 --> 00:57:42.045
AlphaGo에는 지도학습과 강화학습이 섞여있습니다.

00:57:42.045 --> 00:57:51.656
또한 Monte Carlo Tree Search와 같은 오래된 방식과
아주 최신의 deep RL 방법도 섞여있습니다.

00:57:52.579 --> 00:57:56.986
AlphaGo가 어떻게 세계 챔피언을 이길 수 있었을까요?

00:57:56.986 --> 00:58:08.739
우선 입력 벡터를 만들어야 합니다. 우선 바둑판과 바둑 돌의 위치와
같은 요소들을 특징화 시켜 AlpaGo의 입력이 될 수 있도록 합니다.

00:58:08.739 --> 00:58:10.739
이 과정은 상태를 설계하는 아주 자연스러운 단계입니다.

00:58:10.739 --> 00:58:17.958
AlphaGo는 성능 향상을 위해 몇 가지
채널을 조금 더 추가했습니다.

00:58:17.958 --> 00:58:23.790
바둑 돌의 색깔에 따라 채널을 따로 만들기도 했습니다.
이는 바둑판의 형세(configuration)를 표현하는 역할을 합니다.

00:58:23.790 --> 00:58:31.138
그리고 이외에도 몇 가지 채널이 더 추가되었는데 가령
move ligality, bias 채널 등 다양한 채널이 추가되었습니다.

00:58:31.138 --> 00:58:36.518
이렇게 상태를 정의하고 나면
네트워크를 학습시킬 차례입니다.

00:58:36.518 --> 00:58:40.897
네트워크는 프로 바둑기사의 기보를 지도학습으로
학습시켜서 초기화합니다.

00:58:40.897 --> 00:58:48.495
바둑판의 현재 상태가 주어지면
다름 행동을 어떻게 취할지를 결정합니다.

00:58:48.495 --> 00:58:55.608
프로 바둑기사의 기보가 주어지면

00:58:55.608 --> 00:59:02.605
프로 바둑기사가 두는 수들을
supervised mapping으로  학습시킵니다.

00:59:02.605 --> 00:59:05.365
이것이 DeepMind가 AlphaGo를 초기화시켰던 방법이고
상당히 좋은 방법입니다.

00:59:05.365 --> 00:59:09.227
다음 단계는 policy network를 초기화할 차례입니다.

00:59:09.227 --> 00:59:17.778
pilicy network는 바둑판의 상태를 입력으로 받아서
어떤 수를 둬야하는지를 반환해 줍니다.

00:59:17.778 --> 00:59:21.978
지금까지 살펴본 policy gradients가
거의 다 이런식으로 동작했었죠

00:59:21.978 --> 00:59:27.130
이 또한 policy gradients를 이용해서
지속적으로 학습시킵니다.

00:59:27.130 --> 00:59:35.123
그리고 AlphaGo는 임의의 이전 interation에서의
자기 자신과 대국을 두며 학습을 진행합니다.

00:59:35.123 --> 00:59:42.243
스스로 대국을 둬서 이기면 보상을 받고 (1)
지면 -1의 보상을 받습니다.

00:59:42.243 --> 00:59:47.573
그리고 value network도 학습을 해야 합니다.
앞서 critic network로 살펴봤었죠

00:59:47.573 --> 01:00:01.475
최종적인 AlphaGo는 policy/value network와
Monte Carlo Tree Search 알고리즘의 결합된 형태입니다.

01:00:01.475 --> 01:00:19.891
AlphaGo가 다음 수를 어디에 놓을지는 value function
과 MCTS로 계손된 값의 조합으로 결정합니다.

01:00:19.891 --> 01:00:27.453
지금까지 AlphaGo의 기본적인 구성요소를 설명해 드렸습니다.

01:00:28.397 --> 01:00:33.814
더 관심있으신 분들은 2016 nature에 게제된
AlphaGo 논문을 참고하시기 바랍니다.

01:00:34.664 --> 01:00:47.953
지금 대국에 사용하는 AlphaGo는 제 생각에
수천 개의 CPU와 수 백개의 GPU를 이용하고 있습니다.

01:00:47.953 --> 01:00:52.120
아주 엄청난 량의 학습이 필요할 것입니다.

01:00:55.659 --> 01:01:01.529
그리고 이번 주에 있는 경기는 한 번 챙겨보시기
바랍니다. 아주 재미있습니다.

01:01:03.491 --> 01:01:10.858
오늘 한 내용을 요약해봅시다. 오늘 우리는
policy gradients를 배웠습니다. 아주 범용적인 방법입니다.

01:01:10.858 --> 01:01:18.855
gradient descent/ascent를 통해
policy parameters를 직접 업데이트했습니다.

01:01:18.855 --> 01:01:23.947
많은 경우에 잘 동작하긴 하지만
high-variance 문제가 있었습니다.

01:01:23.947 --> 01:01:28.669
이로 인해 아주 많은 샘플이 필요했고
sample-efficiency에 관한 문제가 대두되었습니다.

01:01:28.669 --> 01:01:35.349
우리는 Q-learning에 대해서도 배웠습니다.
이 방법은 항상 잘 동작하지는 않습니다.

01:01:35.349 --> 01:01:46.730
왜냐하면 매우 큰 고차원 공간에서
(상태, 행동) 쌍을 전부 계산해야 하기 때문입니다.

01:01:47.769 --> 01:01:54.322
하지만 Atari의 예 처럼 잘 동작하기만 하면
policy gradients보다는 sample-efficient 합니다.

01:01:54.322 --> 01:01:59.902
Q-learning에서 가장 중요한 것은
중분한 exploration을 해야한다는 것입니다.

01:01:59.902 --> 01:02:04.902
질문있나요?
[학생이 질문]

01:02:14.313 --> 01:02:21.753
질문은 supervised training을
Q-learning에 적용해볼 수 있는지 입니다.

01:02:21.753 --> 01:02:24.924
제 생각에는 Q-learning에 직접 적용하는건
힘들 것 같습니다.

01:02:24.924 --> 01:02:27.532
Q-learning은 Q-values를 regression 하는
과정이기 때문입니다.

01:02:27.532 --> 01:02:46.021
반명 policy gradient는 분포를 다루고 있죠. 그렇긴 해도 다룰 수
있는 방법이 있을 것입니다. 가령 bootstrap 등을 사용하면 말이죠

01:02:47.454 --> 01:02:54.213
이번 시간에 policy gradients와 Q-learning을 다뤘습니다.

01:02:54.213 --> 01:02:56.752
Policy gradient는 어느정도 보장성을 지니고 있습니다.

01:02:56.752 --> 01:03:02.789
Policy gradient는 항상 J(theta)의 local minima로
수렴할 수 있고, 이는 아주 좋은 특성입니다.

01:03:04.339 --> 01:03:12.131
왜냐하면 Policy gradient는 gradient ascent를 직접
수행하기 때문이며, local minima도 제법 괜찮은 편이기 때문이죠

01:03:12.131 --> 01:03:17.041
반면 Q-learning의 경우에는 어떠한 보장도 없습니다.
왜냐하면 Q-learning은

01:03:17.041 --> 01:03:23.358
함수 근사를 통해 벨만 방정식을 근사시키는 것이기 때문입니다.

01:03:23.358 --> 01:03:29.954
이로 인해 다양한 문제에 응용 가능성을 고려해보면
Q-learning은 학습시키기 매우 까다롭다고 할 수 있습니다.

01:03:31.849 --> 01:03:41.546
오늘은 강화학습에 대해 아주 간략한 개요와
주요 알고리즘들을 몇 가지 살펴보았습니다.

01:03:41.546 --> 01:03:47.577
다음 시간에는 Song Han의 guest lecture가 있습니다.

01:03:47.577 --> 01:03:52.569
Song Han은 모델 압축(model compression)과
energy efficient deep learning의 선구자입니다.

01:03:52.569 --> 01:03:56.459
Song Han과 함께 이에 대해서 한번 알아보도록 하겠습니다.

01:03:56.459 --> 01:03:58.459
감사합니다!